package com.ruoyi.spot.openapi.currencyPair.controller;

import com.alibaba.fastjson2.JSON;
import com.alibaba.fastjson2.JSONObject;
import com.fasterxml.jackson.databind.JsonNode;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.ruoyi.spot.constants.SpotMonitorConstants;
import com.ruoyi.spot.openapi.currencyPair.domain.SpotCurrencyPair;
import com.ruoyi.spot.realtime.kline.service.ISpotKlineRealtimeDataService;
import com.ruoyi.util.LarkNewRobotUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;
import org.springframework.stereotype.Controller;
import okhttp3.OkHttpClient;
import okhttp3.Request;
import okhttp3.Response;

import java.io.IOException;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;

/**
 * 现货-同步所有交易对
 */
@Controller
@Component("SpotCurrencyPair")
public class SpotcurrencyPair {

    private static final Logger log = LoggerFactory.getLogger(SpotcurrencyPair.class);

    @Autowired
    private ISpotKlineRealtimeDataService spotKlineRealtimeDataService;

    @Value("${my.lark.newlark}")
    private String newlark;

    public void compareSpotCurrenyPairs() {
        // 1. 从API获取最新的交易对列表
        List<String> apiPairList = getApiCurrencyPairs();
        if (apiPairList.isEmpty()) {
            log.warn("从API获取的现货交易对列表为空，跳过本次同步。");
            return;
        }

        // 2. 从数据库获取【所有】交易对，并处理成Map以便快速查找
        List<SpotCurrencyPair> allDbPairs = spotKlineRealtimeDataService.queryAllDatabasedata();
        Map<String, SpotCurrencyPair> dbPairMap = allDbPairs.stream()
                .collect(Collectors.toMap(SpotCurrencyPair::getCurrencyPair, pair -> pair, (existing, replacement) -> existing));

        log.info("API交易对数量: {}, 数据库总交易对数量: {}", apiPairList.size(), dbPairMap.size());

        // 3. 遍历API列表，处理新增和重新激活的交易对
        for (String apiPair : apiPairList) {
            SpotCurrencyPair existingPair = dbPairMap.get(apiPair);

            if (existingPair == null) {
                // 情况A：数据库中完全不存在，是全新交易对 -> 新增
                String notice = "【币币交易】新交易对上线，名称：" + apiPair;
                log.info(notice);
                LarkNewRobotUtils.notice(notice, newlark);
                spotKlineRealtimeDataService.addnewcurrency_pair(apiPair);

            } else if (!existingPair.isStatues()) { // <-- 修正点: getStatues() 改为 isStatues(), 并判断 false
                // 情况B：数据库中存在，但状态为0（已下线） -> 重新激活
                String notice = "【币币交易】交易对重新上线，名称：" + apiPair;
                log.info(notice);
                LarkNewRobotUtils.notice(notice, newlark);
                spotKlineRealtimeDataService.reactivateCurrencyPair(apiPair);
            }
            // 情况C：数据库中存在且状态为1，则无需任何操作
        }

        // 4. 遍历数据库中的【所有】交易对，处理需要下线的
        for (SpotCurrencyPair dbPair : allDbPairs) {
            if (dbPair.isStatues() && !apiPairList.contains(dbPair.getCurrencyPair())) { // <-- 修正点: getStatues() 改为 isStatues()
                // 如果一个交易对在数据库中是活跃的，但在最新的API列表中找不到，说明它已被下线
                String currencyPair = dbPair.getCurrencyPair();
                String notice = "【币币交易】交易对下线，名称：" + currencyPair;
                log.info(notice);
                LarkNewRobotUtils.notice(notice, newlark);
                spotKlineRealtimeDataService.deletenewcurrency_pair(currencyPair); // 软删除
            }
        }

        log.info("============ChainUp生产巡检-现货交易对变更执行完成============");
    }

    /**
     * 封装了从API获取和解析交易对的逻辑
     * @return API返回的交易对列表
     */
    private List<String> getApiCurrencyPairs() {
        List<String> currencyPairList = new ArrayList<>();
        OkHttpClient client = new OkHttpClient().newBuilder().build();
        try {
            Request request = new Request.Builder()
                    .url(SpotMonitorConstants.SPOT_CURRENCY_PAIR_URL)
                    .get()
                    .build();
            Response response = client.newCall(request).execute();
            String responseBody = response.body().string();
            JSONObject jsonObject = JSON.parseObject(responseBody);
            String symbolsJsonArray = jsonObject.getJSONArray("symbols").toJSONString();

            ObjectMapper objectMapper = new ObjectMapper();
            JsonNode jsonNode = objectMapper.readTree(symbolsJsonArray);

            for (JsonNode element : jsonNode) {
                String symbol = element.path("symbol").asText();
                if (symbol != null && !symbol.isEmpty() && !symbol.contains("-SWAP-")) {
                    String valueToAdd = element.hasNonNull("symbolName")
                            ? element.get("symbolName").asText()
                            : symbol;
                    currencyPairList.add(valueToAdd);
                }
            }
        } catch (IOException e) {
            log.error("获取或解析现货交易对时发生IO异常", e);
        } catch (Exception e) {
            log.error("获取或解析现货交易对时发生未知异常", e);
        }
        return currencyPairList;
    }
}